home *** CD-ROM | disk | FTP | other *** search
/ Aminet 24 / Aminet 24 (1998)(GTI - Schatztruhe)[!][Apr 1998].iso / Aminet / dev / c / AmiVoGL_MDEV.lha / drivers / sun.c < prev    next >
C/C++ Source or Header  |  1994-04-12  |  16KB  |  906 lines

  1.  
  2. /*
  3.  * Vogl/Vogle driver for Sun using sunview.
  4.  *
  5.  */
  6. /*
  7.  * define VOGLE for VOGLE library or leave blank for VOGL library
  8. #define VOGLE 1
  9.  */
  10. #undef VOGLE
  11.  
  12. #include <stdio.h>
  13.  
  14. #include <suntool/sunview.h>
  15. #include <suntool/canvas.h>
  16. #include <fcntl.h>
  17. #include <errno.h>
  18.  
  19. #ifdef SUN_3_5
  20. #define event_action    event_id
  21. #endif
  22.  
  23. #ifdef VOGLE
  24. #include "vogle.h"
  25. #else
  26. #include "vogl.h"
  27. #endif
  28.  
  29. #define    CMAPSIZE    256
  30. #define    STDFONTDIR    "/usr/lib/fonts/fixedwidthfonts/"
  31.  
  32. #define MIN(x,y)    ((x) < (y) ? (x) : (y))
  33.  
  34. #define OP_WHITE    (PIX_SRC | PIX_COLOR(7) | PIX_DONTCLIP)
  35. #define OP_BLACK    (PIX_SRC | PIX_COLOR(0) | PIX_DONTCLIP)
  36. #define COL_WHITE    7
  37. #define COL_BLACK    0
  38.  
  39. static Pixwin    *pw_tmp, *pw;
  40.  
  41. #ifdef BASE_COL_SET
  42. static Pixwin    *pw0;
  43. #endif
  44.  
  45. static Pixrect    *backb;
  46. static Pixfont    *font_id;
  47. static int    wfd, blanket_win;
  48. static int    oldflags;
  49. static int    pwfd, h, w;
  50. static int    colour;
  51. static Rect    wrect;
  52.  
  53. static char    use_sunview_canvas = 0;
  54.  
  55. #define    DASHED        1
  56. #define    FATLINES    2
  57. static unsigned char    lineflags = 0;
  58.  
  59. static Pr_brush    brush = {1};
  60. static Pr_texture    *t = (Pr_texture *)NULL;
  61. static Pr_texture    tex = {
  62.                 (short *)NULL,    
  63.                 0,
  64.                 {1, 1, 1, 0},
  65.                 0,
  66.             };
  67.  
  68. /*
  69.  * default colour map
  70.  */
  71.  
  72. static int    colnum = 8;
  73. static u_char   red[CMAPSIZE] = {
  74.             0, 255, 0, 255, 0, 255, 0, 255, 0,
  75.         },
  76.         green[CMAPSIZE] = {
  77.             0, 0, 255, 255, 0, 0, 255, 255, 0,
  78.         },
  79.         blue[CMAPSIZE] = {
  80.             0, 0, 0, 0, 255, 255, 255, 255, 0,
  81.         };
  82.  
  83. /*
  84.  * redisplay
  85.  *
  86.  *    redisplay the window.
  87.  */
  88. static void redisplay(void)
  89. {
  90.     pw_damaged(pw);
  91.  
  92.     pw_repairretained(pw);
  93.  
  94.     pw_donedamaged(pw);
  95. }
  96.  
  97. /*
  98.  * To be called from a resize procedure from withing sunview
  99.  */
  100. int vo_sunview_canvas_size(
  101.   int sw,
  102.   int sh)
  103. {
  104.     w = sw;
  105.         h = sh;
  106.  
  107.         vdevice.sizeX = vdevice.sizeY = MIN(h, w);
  108.         vdevice.sizeSx = w;
  109.         vdevice.sizeSy = h;
  110.  
  111.     if (pw->pw_prretained) {
  112.         mem_destroy(pw->pw_prretained);
  113.         backb = pw->pw_prretained = mem_create(w, h, vdevice.depth);
  114.     }
  115. }
  116.  
  117. /*
  118.  * vo_sunview_canvas
  119.  *
  120.  *     Tells VOGLE/VOGL to use a supplied sunview pixwin
  121.  */
  122. int vo_sunview_canvas(
  123.   Canvas canvas,
  124.   int cw,
  125.   int ch)
  126. {
  127.     pw = canvas_pixwin(canvas);
  128.     use_sunview_canvas = 1;
  129.  
  130.     w = cw;
  131.     h = ch;
  132.  
  133.     vdevice.sizeX = vdevice.sizeY = MIN(h, w);
  134.     vdevice.sizeSx = w;
  135.     vdevice.sizeSy = h;
  136.  
  137.     vdevice.depth = pw->pw_pixrect->pr_depth;
  138.     if (!pw->pw_prretained)    /* Make us retained */
  139.         backb = pw->pw_prretained = mem_create(w, h, vdevice.depth);
  140.  
  141.     /* 
  142.      *  Set up the color map.  
  143.      */
  144.  
  145.     if (vdevice.depth > 1) {
  146.         pw_setcmsname(pw, "vogle");
  147.         pw_putcolormap(pw, 0, colnum, red, green, blue);
  148.     }
  149.  
  150.     wfd = (int)window_get(canvas, WIN_FD);
  151.  
  152.     /*
  153.      * Set non-blocking input for window.
  154.     oldflags = fcntl(wfd, F_GETFL, 0);
  155.     if (fcntl(wfd, F_SETFL, FNDELAY) < 0) {
  156.         perror("F_SETFL");
  157.         exit(1);
  158.     }
  159.      */
  160.  
  161.  
  162.     pw_batch_on(pw);
  163.  
  164. #ifndef VOGLE
  165.     vdevice.devname = "sun";
  166. #endif
  167.  
  168.     return(1);
  169. }
  170.  
  171. /*
  172.  * SUN_init
  173.  *
  174.  *    initialises drawing canvas to occupy current window
  175.  */
  176. int SUN_init(void)
  177. {
  178.     int        i, prefx, prefy, prefxs, prefys, bw;
  179.     char        name[WIN_NAMESIZE];
  180.     Inputmask    imk, imp;
  181.     int        rootfd;
  182.  
  183.     if (use_sunview_canvas)
  184.         return(1);
  185.  
  186.     pw = (Pixwin *)NULL;
  187.  
  188. #ifdef BASE_COL_SET
  189.     pw0 = pw;
  190. #endif
  191.  
  192.     /*
  193.      * get the gfx win so we have some default sizes to use
  194.      */
  195.     we_getgfxwindow(name);
  196.     pwfd = open(name, 2);
  197.     win_getrect(pwfd, &wrect);
  198.     
  199.         /*
  200.          * Get the input masks of the base window...
  201.          */
  202.         win_get_pick_mask(pwfd, &imp);
  203.         win_get_kbd_mask(pwfd, &imk);
  204.  
  205.  
  206.     /*
  207.      * get a new window (either going to be a blanket window or
  208.      * a window in it's own right)
  209.      */
  210.     if ((wfd = win_getnewwindow()) == -1) {
  211.         fprintf(stderr, "No new windows!\n");
  212.         exit(1);
  213.     }
  214.  
  215.     getprefposandsize(&prefx, &prefy, &prefxs, &prefys);
  216.  
  217.     if (prefx > -1) {
  218.         wrect.r_left = prefx;
  219.         wrect.r_top = prefy;
  220.     }
  221.  
  222.     if (prefxs > -1) {
  223.         wrect.r_width = prefxs;
  224.         wrect.r_height = prefys;
  225.     }
  226.  
  227.     w = wrect.r_width;
  228.     h = wrect.r_height;
  229.  
  230.     bw = 3;
  231.     if (prefx > -1 || prefxs > -1) {
  232.         /*
  233.          * Make room for a 3 pixel border
  234.          */
  235.         if (wrect.r_left <= 2)
  236.             wrect.r_left = 0;
  237.         else
  238.             wrect.r_left -= bw;
  239.  
  240.         if (wrect.r_top <= 2)
  241.             wrect.r_top = 0;
  242.         else
  243.             wrect.r_top -= bw;
  244.  
  245.         wrect.r_width += 2 * bw;
  246.         wrect.r_height += 2 * bw;
  247.  
  248.         win_setrect(wfd, &wrect);
  249.  
  250.         /*
  251.          * get the parent (probably full screen window)
  252.          * so we can size our window to any size we like
  253.          * on the screen.
  254.          */
  255.         we_getparentwindow(name);
  256.         rootfd = open(name, 2);
  257.  
  258.         win_setlink(wfd, WL_PARENT, win_fdtonumber(rootfd));
  259.         win_setlink(wfd, WL_COVERED, WIN_NULLLINK);
  260.         win_insert(wfd);
  261.  
  262.         wmgr_top(wfd, rootfd);
  263.  
  264.         pw = pw_open(wfd);
  265.  
  266. #ifdef BASE_COL_SET
  267.         /*
  268.          * Get the pixrect for the window that we started in
  269.          * so we can set it's colourmap as well
  270.          */
  271.         pw0 = pw_open(pwfd);
  272. #endif
  273.  
  274.         close(rootfd);
  275.         blanket_win = 0;
  276.     } else {
  277.         win_insertblanket(wfd, pwfd);
  278.         pw = pw_region(pw_open(wfd), 0, 0, w, h);
  279.         blanket_win = 1;
  280.     }
  281.  
  282.     /*
  283.      * Set non-blocking input for window.
  284.      */
  285.     oldflags = fcntl(wfd, F_GETFL, 0);
  286.     if (fcntl(wfd, F_SETFL, FNDELAY) < 0) {
  287.         perror("F_SETFL");
  288.         exit(1);
  289.     }
  290.  
  291.     /*
  292.      * Setup the input masks for window.
  293.      */
  294.  
  295.     win_set_kbd_mask(wfd, &imk);
  296.         win_set_pick_mask(wfd, &imp);
  297.  
  298.     vdevice.depth = pw->pw_pixrect->pr_depth;
  299.  
  300.     /* 
  301.      *  Set up the color map.  
  302.      */
  303.  
  304.     if (vdevice.depth > 1) {
  305.         pw_setcmsname(pw, "vogle");
  306.         pw_putcolormap(pw, 0, colnum, red, green, blue);
  307. #ifdef BASE_COL_SET
  308.         if (pw0 != (Pixwin *)NULL) {
  309.             pw_setcmsname(pw0, "vogle");
  310.             pw_putcolormap(pw0, 0, colnum, red, green, blue);
  311.         }
  312. #endif
  313.     }
  314.  
  315.     if (prefx > -1 || prefxs > -1) {
  316.         /*
  317.          * Draw the border...
  318.          */
  319.         int    x0, y0, x1, y1;
  320.  
  321.         x0 = y0 = 0;
  322.         x1 = wrect.r_width - 1;
  323.         y1 = 0;
  324.         pw_vector(pw, x0, y0, x1, y1, OP_WHITE, COL_WHITE);
  325.         pw_vector(pw, x0 + 2, y0 + 2, x1 - 2, y1 + 2, OP_WHITE, COL_WHITE);
  326.         pw_vector(pw, x0 + 1, y0 + 1, x1 - 1, y1 + 1, OP_BLACK, COL_BLACK);
  327.         x0 = x1;
  328.         y0 = y1;
  329.         x1 = x0;
  330.         y1 = wrect.r_height - 1;
  331.         pw_vector(pw, x0, y0, x1, y1, OP_WHITE, COL_WHITE);
  332.         pw_vector(pw, x0 - 2, y0 + 2, x1 - 2, y1 - 2, OP_WHITE, COL_WHITE);
  333.         pw_vector(pw, x0 - 1, y0 + 1, x1 - 1, y1 - 1, OP_BLACK, COL_BLACK);
  334.         x0 = x1;
  335.         y0 = y1;
  336.         x1 = 0;
  337.         y1 = wrect.r_height - 1;
  338.         pw_vector(pw, x0, y0, x1, y1, OP_WHITE, COL_WHITE);
  339.         pw_vector(pw, x0 - 2, y0 - 2, x1 + 2, y1 - 2, OP_WHITE, COL_WHITE);
  340.         pw_vector(pw, x0 - 1, y0 - 1, x1 + 1, y1 - 1, OP_BLACK, COL_BLACK);
  341.         x0 = x1;
  342.         y0 = y1;
  343.         x1 = 0;
  344.         y1 = 0;
  345.         pw_vector(pw, x0, y0, x1, y1, OP_WHITE, COL_WHITE);
  346.         pw_vector(pw, x0 + 2, y0 - 2, x1 + 2, y1 + 2, OP_WHITE, COL_WHITE);
  347.         pw_vector(pw, x0 + 1, y0 - 1, x1 + 1, y1 + 1, OP_BLACK, COL_BLACK);
  348.         pw_tmp = pw;
  349.         pw = pw_region(pw_tmp, 3, 3, w, h);
  350.         pw_close(pw_tmp);
  351.     }
  352.  
  353.  
  354.     backb = pw->pw_prretained = mem_create(w, h, vdevice.depth);
  355.  
  356.     signal(SIGWINCH, redisplay);
  357.  
  358.     /*
  359.      *  Let VOGLE/VOGL know about the window size.
  360.      */
  361.         vdevice.sizeX = vdevice.sizeY = MIN(w, h);
  362.     vdevice.sizeSx = w;
  363.     vdevice.sizeSy = h;
  364.  
  365.     /*
  366.      * Set up batching.....(for speed and "pseudo" double buffering)
  367.      */
  368.     pw_batch_on(pw);
  369.  
  370.     return(1);
  371. }
  372.  
  373. /*
  374.  * SUN_exit
  375.  *
  376.  *    cleans up before returning the window to normal.
  377.  */
  378. int SUN_exit(void)
  379. {
  380.     long    nbytes;
  381.     int    i;
  382.     Event    event;
  383.  
  384.     if (use_sunview_canvas)
  385.         return(1);
  386.  
  387.     /*
  388.      * Flush all events for this window.
  389.      *
  390.      * While doing non-blocking input input_readevent returns -1 and
  391.      * errno == EWOULDBLOCK when everything has been read, so if 
  392.      * errno != EWOULDBLOCK then something naughty happened...
  393.      */
  394.     while (input_readevent(wfd, &event) >= 0)
  395.         ;
  396.  
  397.     if (errno != EWOULDBLOCK) {
  398.         perror("SUN_exit(flushing), input_readevent");
  399.         exit();
  400.     }
  401.  
  402.     /*
  403.      * reset wfd to blocking input.
  404.      */
  405.     if (fcntl(wfd, F_SETFL, oldflags) < 0) {
  406.         perror("oldflags, F_SETFL");
  407.         exit(1);
  408.     }
  409.  
  410.     if (blanket_win)
  411.         win_removeblanket(wfd);
  412.     else 
  413.         win_remove(wfd);
  414.  
  415.     signal(SIGWINCH, SIG_DFL);
  416.  
  417.     return(1);
  418. }
  419.  
  420. /*
  421.  * SUN_draw
  422.  *
  423.  *    draws a line from the current graphics position to (x, y).
  424.  *
  425.  * Note: (0, 0) is defined as the top left of the window on a sun (easy
  426.  * to forget).
  427.  */
  428. int SUN_draw(
  429.   int x,
  430.   int y)
  431. {
  432.     if (!lineflags)    /* If thin and solid */
  433.         pw_vector(pw, vdevice.cpVx, vdevice.sizeSy - vdevice.cpVy, x, vdevice.sizeSy - y, PIX_SRC | PIX_COLOR(colour), colour);
  434.     else    /*